package com.algorithm.array.interfaces.impl;

import com.algorithm.array.interfaces.List;


/**
 * 手写一个ArrayList 容器
 */
public class ArrayList implements List {

    private  int size=0;//定义初始化的长度
    private  int[] element; //定义初始化的数组

    private static int DEFAULT_SIZE=10; //默认初始化的大小

    /**
     * 默认初始化
     */
    public  ArrayList(){
        this.element=new int[DEFAULT_SIZE];
    }

    /**
     * 自定义容量大小
     * @param capacity
     */
    public ArrayList(int capacity){
        this.element=new int[capacity];
    }

    @Override
    public boolean add(int value) {
        //检查容量 如果容量不足 进行动态扩容
        checkCapacity(size+1);
        element[size++]=value;
        return true;
    }


    @Override
    public int get(int index) {
        //判断下标是否越界
        checkIndexOutOfBounds(index);
        return element[index];
    }


    @Override
    public int remove(int index) {
        //判断下标是否越界
        checkIndexOutOfBounds(index);
        //获取需要删除的元素
        int remValue=element[index];
        if(size-index==1){
            element[--size]=0;
            return remValue;
        }
        //后面的元素往前移动
        System.arraycopy(element,index+1,element,index,size-index);
        //清除最后一个节点的数据
        element[--size]=0;
        return remValue;
    }

    @Override
    public boolean clear() {
        //清楚数组全部数据
       for(int i=0;i<size;i++){
            element[i]=0;
       }
        return true;
    }


    @Override
    public boolean put(int index, int value) {
        //检查数组下标是否越界
        checkIndexOutOfBounds(index);
        element[index]=value;
        return true;
    }

    @Override
    public boolean insert(int index, int value) {
        //检查容器是否需要扩容
        checkCapacity(size+1);
        //检查下标是否越界 最大可以到size 即在尾部插入
        checkIndexOutOfBounds(index,size);
        //将插入点后的元素后移
        if(index==size){
            element[index]=value;
            size++;
            return true;
        }
        System.arraycopy(element,index,element,index+1,size-index);
        element[index]=value;
        size++;
        return true;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return getSize()!=0;
    }

    @Override
    public int indexOf(int value) {
        for(int i=0;i<size;i++){
            if (element[i]==value) {
                return i;
            }
        }
        return -1;
    }


    /**
     * 检查容龄
     * @param minCapacity
     */
    private void checkCapacity(int minCapacity) {
        int capacity=element.length;//当前容量
        if(capacity<minCapacity){
            //动态扩容 1.5 倍
            int newCapacity=capacity+ capacity>>1;
            if(newCapacity<minCapacity){
                newCapacity=minCapacity;
            }
            int[] newArray = new int[newCapacity];
            //复制 将原来的值复制给新的数组
            System.arraycopy(element,0,newArray,0,size);
            element=newArray;
        }

    }

    private void checkIndexOutOfBounds(int index) {
        if(index<0 || index>size-1){
            throw  new IndexOutOfBoundsException();
        }
    }

    private void checkIndexOutOfBounds(int index,int maxCapacity) {
        if(index<0 || index>maxCapacity){
            throw  new IndexOutOfBoundsException();
        }
    }

    @Override
    public String toString(){
        StringBuffer buffer=new StringBuffer();
        buffer.append("[");
        for(int i=0;i<size;i++){
            buffer.append(element[i]+",");
        }
        buffer.append("]");
        return buffer.toString();
    }
}
